/*

* 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:  It completes on a change in the volume property.  Used for 

*                the new Central Repository Server.  Used in EKA2 builds only

*

*/

#include <eikapp.h>

#include <aknconsts.h>

#include <browseruisdkcrkeys.h>

#include "VolumeKeyListener.h" 

#include "MRepositoryVolumeObserver.h"

// CONSTANTS

const TInt KFirstTimerExpiryInterval = 1; // Expire immediately

const TInt KTimerExpiryInterval = KAknStandardKeyboardRepeatRate;

const TInt KMinVolume = 0;  // Minimum volume level(Mute)

const TInt KMaxVolume = 10; // Maximum volume level

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

// CVolumeKeyListener::NewL

// Description: static constructor.

// Output: none

// Return: CVolumeKeyListener object

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

CVolumeKeyListener* CVolumeKeyListener::NewL( MRepositoryVolumeObserver* aObserver )

    {

    CVolumeKeyListener* self = new(ELeave) CVolumeKeyListener(

                                                                aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CVolumeKeyListener::CVolumeKeyListener

// Description: constructor.

// Output: none

// Return: none

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

CVolumeKeyListener::CVolumeKeyListener( MRepositoryVolumeObserver* aObserver ):

                                                iInterfaceSelector(NULL),

                                                iSelector(NULL),

                                                iCenRepos(NULL),

                                                iObserver(aObserver)

    {

    }   

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

// CVolumeKeyListener::ConstructL

// Description: second phase constructor.

// Input:  aObserver: link to the calling object

// Output: none

// Return: none

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

void CVolumeKeyListener::ConstructL()

    {

    //

    // Open a connection to receive Volume Key events.

    iSelector = CRemConInterfaceSelector::NewL();

    iInterfaceSelector = CRemConCoreApiTarget::NewL(*iSelector,*this);

    TRAP_IGNORE(iSelector->OpenTargetL());

    // Timer for implementing repeat

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

    //

    // Open a connection to the Central Repository...

    iCenRepos = CRepository::NewL(KCRUidBrowser);

    //    iObservers=new(ELeave)CArrayFixSeg<MVolumePropertyWatchObserver*>

    //                (KVolumeObserversArrayGranularity);

    }

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

// CVolumeKeyListener::~CVolumeKeyListener

// Description: destructor.

// Input:  none

// Output: none

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

CVolumeKeyListener::~CVolumeKeyListener()

    {

    if(iSelector)

        {

        delete iSelector;

        iInterfaceSelector=NULL;

        iSelector=NULL; //iSelector has been deleted by "delete iInterfaceSelector"

        }

    if(iTimer)

        {

        iTimer->Cancel();

        delete iTimer;

        }

    if(iCenRepos)

        {

        delete iCenRepos;

        }

    }

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

// CVolumeKeyListener::SetObserver

// Description: Used to set an observer 

// Input:  aObserver: Point to observer

// Output: none

// Return: none

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

void CVolumeKeyListener::SetObserver( MRepositoryVolumeObserver* aObserver)

    {

    iObserver = aObserver;

    }

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

// CVolumeKeyListener::GetCurrentVolume

// Description: gets the current volume level from the 

//   central directory.

// Input:  none

// Output: none

// Return: volume level

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

TInt CVolumeKeyListener::GetCurrentVolume()

    {

    TInt currentVolume = 0;

    //

    // Get the current volume

    if(iCenRepos)

        iCenRepos->Get(KBrowserMediaVolumeControl, currentVolume);

/*

    #if defined(__WINSCW__) //offset required on the emulator

        currentVolume += WINS_DEFAULT_VOLUME;

    #endif

*/

    return currentVolume;

    }

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

// CVolumeKeyListener::MrccatoCommand

// Description: A Volume key command has been received

//        (from MRemConCoreApiTargetObserver)

// Input:aOperationId The operation ID of the command

//         aButtonAct The button action associated with the command.

// Output: none

// Return: none

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

void CVolumeKeyListener::MrccatoCommand(TRemConCoreApiOperationId aOperationId, 

                             TRemConCoreApiButtonAction aButtonAct )

    {

    switch(aOperationId)

        {

        case ERemConCoreApiVolumeUp:

            {

            switch (aButtonAct)

                {

                case ERemConCoreApiButtonPress:

                    {

                     //Start Timer

                     if (!iTimer->IsActive())

                        {

                        iCommandId = EVolumeControlCmdVolumeUpByOne;

                        iTimer->Start(KFirstTimerExpiryInterval,

                                      KTimerExpiryInterval, 

                                      TCallBack(TimerCallback, this));

                        }

                    break;

                    }

                case ERemConCoreApiButtonRelease:

                    {

                    iTimer->Cancel();

                    break;

                    }

                case ERemConCoreApiButtonClick:

                    {

                    FilterAndSendCommand(EVolumeControlCmdVolumeUpByOne);

                    break;

                    }

                default:

                    {

                    break;

                    }

                }

            break;

            }

        case ERemConCoreApiVolumeDown:

            {

            switch (aButtonAct)

                {

                case ERemConCoreApiButtonPress:

                    {

                    //Start Timer

                    iCommandId = EVolumeControlCmdVolumeDownByOne;

                    if (!iTimer->IsActive())

                        {

                        iTimer->Start(KFirstTimerExpiryInterval,

                                      KTimerExpiryInterval, 

                                      TCallBack(TimerCallback, this));

                        }

                     break;

                    }

                case ERemConCoreApiButtonRelease:

                    {

                    iTimer->Cancel();

                    break;

                    }

                case ERemConCoreApiButtonClick:

                    {

                    FilterAndSendCommand(EVolumeControlCmdVolumeDownByOne);

                    break;

                    }

                default:

                    {

                    break;

                    }

                }

            break;

            }

        default:

            {

            break;

            }

        }        

    }        

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

// CVolumeKeyListener::HandleRepeatEvent

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

//

void CVolumeKeyListener::HandleRepeatEvent()

    {

    FilterAndSendCommand(iCommandId);

    }

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

// CVolumeKeyListener::TimerCallback

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

//

TInt CVolumeKeyListener::TimerCallback(TAny* aPtr)

    {

    static_cast<CVolumeKeyListener*>(aPtr)->HandleRepeatEvent();

    return KErrNone;

    }

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

// CVolumeKeyListener::FilterAndSendCommand

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

//

void CVolumeKeyListener::FilterAndSendCommand(TInt aCommandId)

    {

    TInt currentVolume = 0;

    iCenRepos->Get(KBrowserMediaVolumeControl,currentVolume);

    switch(aCommandId)

        {

        case EVolumeControlCmdVolumeUpByOne:

            currentVolume=(currentVolume< KMaxVolume)? ++currentVolume : KMaxVolume;

            break;

        case EVolumeControlCmdVolumeDownByOne:

            currentVolume=(currentVolume> KMinVolume)? --currentVolume : KMinVolume;

            break;  

        default:

            break;      

        }

    iCenRepos->Set(KBrowserMediaVolumeControl,currentVolume);

#if defined(__WINS__) //offset required on the emulator

        currentVolume += WINS_DEFAULT_VOLUME;

#endif   

    if(iObserver)

        iObserver->VolumeChanged(currentVolume);

    }

// End of File